package com.example.hello.service;

import com.example.hello.common.PageResult;
import com.example.hello.entity.Employee;
import com.example.hello.entity.Order;
import com.example.hello.mapper.EmployeeMapper;
import com.example.hello.mapper.OrderMapper;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.List;

@Service
public class OrderService {

    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private EmployeeMapper employeeMapper;

    /**
     * 分页查询订单列表
     */
    public PageResult<Order> getOrderList(String number, String status, Integer empId,
                                        LocalDate startDate, LocalDate endDate,
                                        Integer page, Integer pageSize) {
        // 将日期转换为日期时间
        LocalDateTime startTime = startDate != null ? startDate.atStartOfDay() : null;
        LocalDateTime endTime = endDate != null ? endDate.atTime(LocalTime.MAX) : null;

        log.info("查询订单列表参数: number={}, status={}, empId={}, startTime={}, endTime={}, page={}, pageSize={}",
                 number, status, empId, startTime, endTime, page, pageSize);

        PageHelper.startPage(page, pageSize);
        Page<Order> orderPage = (Page<Order>) orderMapper.selectOrderList(
                number, status, empId, startTime, endTime);
        return new PageResult<>(orderPage.getTotal(), orderPage.getResult());
    }

    /**
     * 根据ID查询订单
     */
    public Order getOrderById(Integer id) {
        return orderMapper.selectById(id);
    }

    /**
     * 新增订单
     */
    @Transactional
    public Integer addOrder(Order order) {
        // 参数校验
        validateOrder(order);
        
        // 设置创建时间和更新时间
        LocalDateTime now = LocalDateTime.now();
        order.setUpdateTime(now);
        
        // 处理over_time字段，避免null值
        if ("已完成".equals(order.getStatus())) {
            order.setOverTime(now); // 已完成订单使用当前时间
        } else {
            // 为非完成状态订单设置默认的预计完成时间（如3天后）
            order.setOverTime(now.plusDays(3));
        }
        
        // 插入订单
        orderMapper.insert(order);
        
        return order.getId();
    }

    /**
     * 修改订单信息
     */
    @Transactional
    public boolean updateOrder(Integer id, Order order) {
        // 设置ID和更新时间
        order.setId(id);
        order.setUpdateTime(LocalDateTime.now());

        // 获取现有订单信息
        Order existingOrder = orderMapper.selectById(id);
        if (existingOrder == null) {
            return false;
        }

        // 参数校验
        validateOrderForUpdate(order, existingOrder);

        // 更新订单信息
        return orderMapper.update(order) > 0;
    }

    /**
     * 删除订单
     */
    @Transactional
    public boolean deleteOrder(Integer id) {
        // 查询订单是否存在
        Order order = orderMapper.selectById(id);
        if (order == null) {
            return false;
        }
        
        // 只允许删除"已取消"状态的订单，或添加其他业务规则
        if (!"已取消".equals(order.getStatus())) {
            throw new IllegalStateException("只能删除已取消的订单");
        }
        
        return orderMapper.deleteById(id) > 0;
    }

    /**
     * 取消订单
     */
    @Transactional
    public boolean cancelOrder(Integer id) {
        // 查询订单是否存在
        Order order = orderMapper.selectById(id);
        if (order == null) {
            return false;
        }
        
        // 已完成的订单不能取消
        if ("已完成".equals(order.getStatus())) {
            throw new IllegalStateException("已完成的订单不能取消");
        }
        
        // 已取消的订单不能再次取消
        if ("已取消".equals(order.getStatus())) {
            throw new IllegalStateException("订单已经是取消状态");
        }
        
        // 创建更新对象
        Order updateOrder = new Order();
        updateOrder.setId(id);
        updateOrder.setStatus("已取消");
        updateOrder.setUpdateTime(LocalDateTime.now());
        
        // 使用update方法替代updateStatus
        return orderMapper.update(updateOrder) > 0;
    }

    /**
     * 完成订单
     */
    @Transactional
    public boolean completeOrder(Integer id) {
        // 查询订单是否存在
        Order order = orderMapper.selectById(id);
        if (order == null) {
            return false;
        }
        
        // 已完成的订单不能再次完成
        if ("已完成".equals(order.getStatus())) {
            throw new IllegalStateException("订单已经是完成状态");
        }
        
        // 已取消的订单不能再完成
        if ("已取消".equals(order.getStatus())) {
            throw new IllegalStateException("已取消的订单不能完成");
        }
        
        // 设置当前时间为完成时间
        LocalDateTime now = LocalDateTime.now();
        
        // 创建更新对象
        Order updateOrder = new Order();
        updateOrder.setId(id);
        updateOrder.setStatus("已完成");
        updateOrder.setOverTime(now);
        updateOrder.setUpdateTime(now);
        
        // 使用update方法
        return orderMapper.update(updateOrder) > 0;
    }

    /**
     * 更新订单状态
     */
    private boolean updateOrderStatus(Integer id, String status) {
        // 查询订单是否存在
        Order order = orderMapper.selectById(id);
        if (order == null) {
            return false;
        }
        
        // 如果状态是"已完成"，则设置完成时间
        if ("已完成".equals(status)) {
            LocalDateTime now = LocalDateTime.now();
            return orderMapper.updateStatusAndOverTime(id, status, now, now) > 0;
        } else {
            return orderMapper.updateStatus(id, status, LocalDateTime.now()) > 0;
        }
    }

    /**
     * 校验订单信息（新增时）
     */
    private void validateOrder(Order order) {
        // 校验订单号
        if (order.getNumber() == null || order.getNumber().isEmpty()) {
            throw new IllegalArgumentException("订单号不能为空");
        }

        // 校验订单号唯一性
        Order existingOrder = orderMapper.selectByNumber(order.getNumber());
        if (existingOrder != null) {
            throw new IllegalArgumentException("订单号已存在");
        }

        // 校验状态
        if (order.getStatus() == null || order.getStatus().isEmpty()) {
            throw new IllegalArgumentException("订单状态不能为空");
        }

        String status = order.getStatus();
        if (!status.equals("进行中") && !status.equals("已完成") && !status.equals("已取消")) {
            throw new IllegalArgumentException("订单状态只能是：进行中、已完成、已取消");
        }

        // 校验员工ID
        if (order.getEmpId() == null) {
            throw new IllegalArgumentException("员工ID不能为空");
        }

        // 验证员工是否存在
        Employee employee = employeeMapper.selectById(order.getEmpId());
        if (employee == null) {
            throw new IllegalArgumentException("员工不存在");
        }

        // 校验订单时间
        if (order.getOrderTime() == null) {
            throw new IllegalArgumentException("订单时间不能为空");
        }

        // 校验金额
        if (order.getAmount() == null) {
            throw new IllegalArgumentException("订单金额不能为空");
        }

        if (order.getAmount().compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("订单金额不能为负数");
        }
    }

    /**
     * 校验订单更新信息
     */
    private void validateOrderForUpdate(Order order, Order existingOrder) {
        // 校验状态
        if (order.getStatus() != null) {
            String status = order.getStatus();
            if (!status.equals("进行中") && !status.equals("已完成") && !status.equals("已取消")) {
                throw new IllegalArgumentException("订单状态只能是：进行中、已完成、已取消");
            }
        }

        // 校验员工ID
        if (order.getEmpId() != null) {
            // 验证员工是否存在
            Employee employee = employeeMapper.selectById(order.getEmpId());
            if (employee == null) {
                throw new IllegalArgumentException("员工不存在");
            }
        }

        // 校验金额
        if (order.getAmount() != null && order.getAmount().compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("订单金额不能为负数");
        }
    }
} 